'use strict';

/**
 * UniPush 2.0 推送云函数
 * 根据官方文档正确实现
 */

exports.main = async (event, context) => {
  console.log('📲 收到推送请求 event:', JSON.stringify(event));

  try {
    // 0. 初始化推送管理器（尝试不同的参数名称）
    console.log('🔧 初始化 uniPush...');
    const uniPush = uniCloud.getPushManager({
      appId: '__UNI__A079ADC'
    });
    console.log('✅ uniPush 初始化成功');

    // 1. 解析参数
    let params = {};

    if (event.body) {
      try {
        params = typeof event.body === 'string' ? JSON.parse(event.body) : event.body;
      } catch (e) {
        console.error('❌ 解析参数失败:', e);
        return { code: 400, message: '请求体格式错误' };
      }
    } else if (event.data) {
      params = event.data;
    } else {
      params = event;
    }

    console.log('📋 解析后的参数:', JSON.stringify(params));

    // 2. 参数验证
    const { clientId, title, content, payload } = params;

    if (!clientId) {
      return { code: 400, message: '缺少 clientId 参数', data: null };
    }

    if (!title || !content) {
      return { code: 400, message: '缺少 title 或 content 参数', data: null };
    }

    // 3. 处理 payload（兼容数字类型和对象类型）
    let finalPayload = {};
    if (payload !== null && payload !== undefined) {
      if (typeof payload === 'number') {
        // 如果是数字，包装成对象（兼容后端直接传 Long 类型）
        finalPayload = { documentId: payload };
        console.log('📦 payload 是数字，已包装为对象:', finalPayload);
      } else if (typeof payload === 'string') {
        // 如果是字符串，尝试解析为 JSON
        try {
          finalPayload = JSON.parse(payload);
          console.log('📦 payload 是字符串，已解析为对象:', finalPayload);
        } catch (e) {
          // 如果解析失败，尝试转换为数字
          const numPayload = Number(payload);
          if (!isNaN(numPayload)) {
            finalPayload = { documentId: numPayload };
            console.log('📦 payload 字符串转数字，已包装为对象:', finalPayload);
          } else {
            finalPayload = { raw: payload };
            console.log('📦 payload 字符串无法解析，使用原始值:', finalPayload);
          }
        }
      } else if (typeof payload === 'object') {
        // 如果已经是对象，直接使用
        finalPayload = payload;
        console.log('📦 payload 是对象，直接使用:', finalPayload);
      }
    }

    // 4. 构建推送消息
    const pushMessage = {
      push_clientid: clientId,
      title: title,
      content: content,
      payload: finalPayload,
      force_notification: true  // 强制显示通知（即使App在前台）
    };

    console.log('📤 准备推送:', JSON.stringify(pushMessage, null, 2));

    // 5. 调用推送（使用官方文档的方法）
    console.log('📡 调用 uniPush.sendMessage...');
    console.log('📤 推送消息参数:', JSON.stringify(pushMessage, null, 2));

    const result = await uniPush.sendMessage(pushMessage);

    console.log('✅ 推送调用完成，返回结果:', JSON.stringify(result, null, 2));

    // 🔍 详细分析返回结果的参数结构
    if (result) {
      console.log('📋 ========== sendMessage 返回结果参数分析 ==========');
      console.log('📋 返回结果类型:', typeof result);
      console.log('📋 返回结果是否为对象:', typeof result === 'object');

      // 列出所有字段名
      if (typeof result === 'object' && result !== null) {
        const keys = Object.keys(result);
        console.log('📋 返回结果的所有字段:', keys);
        console.log('📋 字段数量:', keys.length);

        // 逐个输出每个字段的值
        keys.forEach((key) => {
          const value = result[key];
          const valueType = typeof value;
          console.log(`📋   - ${key}: ${valueType} = ${JSON.stringify(value)}`);
        });
      }

      // 检查常见字段
      console.log('📋 ---------- 常见字段检查 ----------');
      console.log('📋   errCode:', result.errCode, '(类型:', typeof result.errCode, ')');
      console.log('📋   errMsg:', result.errMsg, '(类型:', typeof result.errMsg, ')');
      console.log('📋   taskId:', result.taskId, '(类型:', typeof result.taskId, ')');
      console.log('📋   task_id:', result.task_id, '(类型:', typeof result.task_id, ')');
      console.log('📋   taskid:', result.taskid, '(类型:', typeof result.taskid, ')');
      console.log('📋   taskID:', result.taskID, '(类型:', typeof result.taskID, ')');
      console.log('📋   data:', result.data, '(类型:', typeof result.data, ')');

      // 如果 result.data 是对象，也检查其字段
      if (result.data && typeof result.data === 'object') {
        console.log('📋   data 字段详情:');
        const dataKeys = Object.keys(result.data);
        dataKeys.forEach((key) => {
          const value = result.data[key];
          console.log(`📋     - data.${key}: ${typeof value} = ${JSON.stringify(value)}`);
        });
      }

      console.log('📋 ============================================');
    } else {
      console.log('⚠️ sendMessage 返回结果为 null 或 undefined');
    }

    // 提取 taskId（从返回结果中获取）
    let taskId = null;
    if (result) {
      // 尝试从不同字段获取 taskId
      taskId = result.taskId || result.task_id || result.taskid || result.taskID || null;

      // 如果 result.data 是对象，也尝试从 data 中获取
      if (!taskId && result.data) {
        if (typeof result.data === 'object') {
          taskId = result.data.taskId || result.data.task_id || result.data.taskid || result.data.taskID || null;
        }
      }

      // 如果有 taskId，记录日志
      if (taskId) {
        console.log('📋 ✅ 推送任务ID (taskId) 已找到:', taskId);
      } else {
        console.log('⚠️ 推送结果中未找到 taskId，可能服务不支持任务ID追踪');
        console.log('推送结果的所有字段:', Object.keys(result || {}));
      }
    }

    // 构建返回数据（包含 taskId 和完整的推送结果）
    const responseData = {
      taskId: taskId,  // 👈 推送任务ID
      clientId: clientId,  // 👈 设备ClientID（便于追踪）
      result: result  // 👈 完整的推送结果
    };

    // 检查推送结果
    if (result && result.errCode !== undefined) {
      if (result.errCode === 0 || result.errCode === '0') {
        console.log('✅✅✅ 推送成功！errCode=0');
        return {
          code: 0,
          message: '推送成功',
          data: responseData
        };
      } else {
        // 🔥 推送失败，返回错误信息
        console.error('❌❌❌ 推送失败！错误码:', result.errCode, '错误信息:', result.errMsg);
        return {
          code: 500,
          message: `推送失败: ${result.errMsg || '未知错误'} (错误码: ${result.errCode})`,
          data: responseData,  // 即使失败也返回 taskId（如果有）
          errCode: result.errCode,
          errMsg: result.errMsg
        };
      }
    } else {
      // 如果没有错误码，认为成功
      console.log('✅ 推送调用成功（无错误码）');
      return {
        code: 0,
        message: '推送成功',
        data: responseData
      };
    }

  } catch (error) {
    console.error('❌ 推送失败:', error);
    console.error('错误类型:', error.name);
    console.error('错误消息:', error.message);
    console.error('错误堆栈:', error.stack);

    return {
      code: 500,
      message: error.message || '推送失败',
      data: null,
      error: {
        name: error.name,
        message: error.message,
        stack: error.stack
      }
    };
  }
};
